﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using Estructuras.Comunes;

namespace Estructuras.Consola.ConsolaTransformarCondicional
{
    /// <summary>
    /// Almacena las propiedades de un elemento específico.
    /// </summary>
    public class PTransformarCondicional : Propiedades
    {
        /// <summary>
        /// Entrada de datos.
        /// </summary>
        public string Entrada
        {
            get
            {
                return this.getPropiedadString(CTransformarCondicional.Entrada);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.Entrada, value);
            }
        }

        /// <summary>
        /// Salida de datos.
        /// </summary>
        public string Salida
        {
            get
            {
                return this.getPropiedadString(CTransformarCondicional.Salida);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.Salida, value);
            }
        }

        /// <summary>
        /// Estructura de entrada.
        /// </summary>
        public string EstructuraEntrada
        {
            get
            {
                return this.getPropiedadString(CTransformarCondicional.EstructuraEntrada);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.EstructuraEntrada, value);
            }
        }

        /// <summary>
        /// Estructura de salida.
        /// </summary>
        public string EstructuraSalida
        {
            get
            {
                return this.getPropiedadString(CTransformarCondicional.EstructuraSalida);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.EstructuraSalida, value);
            }
        }

        /// <summary>
        /// Lista de condiciones.
        /// </summary>
        public List<string> ListaCondiciones
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.Condiciones);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.Condiciones, value);
            }
        }

        /// <summary>
        /// Lista de campos sobre los que aplicar condiciones.
        /// </summary>
        public List<string> ListaCamposCondiciones
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.CamposCondiciones);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.CamposCondiciones, value);
            }
        }

        /// <summary>
        /// Lista de parámetros de las condiciones.
        /// </summary>
        public List<List<string>> ListaParametrosCondiciones
        {
            get
            {
                return this.getPropiedadListaListaString(CTransformarCondicional.ParametrosCondiciones);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.ParametrosCondiciones, value);
            }
        }

        /// <summary>
        /// Lista de funciones para cuando se cumple la condición.
        /// </summary>
        public List<string> ListaFuncionesVerdadero
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.FuncionesVerdadero);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.FuncionesVerdadero, value);
            }
        }

        /// <summary>
        /// Lista de campos origen a los que aplica las funciones para cuando se cumple la condición.
        /// </summary>
        public List<string> ListaCamposOrigenVerdadero
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.CamposOrigenVerdadero);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.CamposOrigenVerdadero, value);
            }
        }

        /// <summary>
        /// Lista de campos destino a los que aplica las funciones para cuando se cumple la condición.
        /// </summary>
        public List<string> ListaCamposDestinoVerdadero
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.CamposDestinoVerdadero);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.CamposDestinoVerdadero, value);
            }
        }

        /// <summary>
        /// Lista de parámetros de las funciones para cuando se cumple la condición.
        /// </summary>
        public List<List<string>> ListaParametrosVerdadero
        {
            get
            {
                return this.getPropiedadListaListaString(CTransformarCondicional.ParametrosVerdadero);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.ParametrosVerdadero, value);
            }
        }

        /// <summary>
        /// Lista de funciones para cuando no se cumple la condición.
        /// </summary>
        public List<string> ListaFuncionesFalso
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.FuncionesFalso);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.FuncionesFalso, value);
            }
        }

        /// <summary>
        /// Lista de campos origen a los que aplica las funciones para cuando no se cumple la condición.
        /// </summary>
        public List<string> ListaCamposOrigenFalso
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.CamposOrigenFalso);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.CamposOrigenFalso, value);
            }
        }

        /// <summary>
        /// Lista de campos destino a los que aplica las funciones para cuando no se cumple la condición.
        /// </summary>
        public List<string> ListaCamposDestinoFalso
        {
            get
            {
                return this.getPropiedadListaString(CTransformarCondicional.CamposDestinoFalso);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.CamposDestinoFalso, value);
            }
        }

        /// <summary>
        /// Lista de parámetros de las funciones para cuando no se cumple la condición.
        /// </summary>
        public List<List<string>> ListaParametrosFalso
        {
            get
            {
                return this.getPropiedadListaListaString(CTransformarCondicional.ParametrosFalso);
            }
            set
            {
                this.setOrAddPropiedad(CTransformarCondicional.ParametrosFalso, value);
            }
        }

        /// <summary>
        /// Constructor por defecto.
        /// </summary>
        public PTransformarCondicional()
            : base()
        {
        }

        /// <summary>
        /// Obtiene los parámetros a partir del fichero XML indicado.
        /// </summary>
        /// <param name="fichero">Fichero de configuración XML</param>
        override public void leer(string fichero)
        {
            base.leer(fichero);
            XmlDocument xml = LeerXml.AbrirFicheroParametros(fichero);

            this.Entrada = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaEntrada);
            this.Salida = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaSalida);
            this.EstructuraEntrada = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaEstructuraEntrada);
            this.EstructuraSalida = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaEstructuraSalida);

            // Condiciones
            int numeroCondiciones = LeerXml.ObtenerNumeroNodosCampo(xml, CTransformarCondicional.RutaCondiciones);
            for (int indiceCondicion = 0; indiceCondicion < numeroCondiciones; indiceCondicion++)
            {
                string condicion = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionFuncion);
                if (!string.Empty.Equals(condicion))
                {
                    this.ListaCondiciones.Add(condicion);

                    // Campo
                    string campo = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionCampo);
                    this.ListaCamposCondiciones.Add(campo);

                    // Parametros
                    List<string> parametros = new List<string>();
                    int numeroParametros = LeerXml.ObtenerNumeroNodosCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionParametros);
                    for (int indiceParametro = 0; indiceParametro < numeroParametros; indiceParametro++)
                    {
                        try
                        {
                            string parametro = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionParametros, indiceParametro);
                            parametros.Add(parametro);
                        }
                        catch (Excepcion)
                        { parametros.Add(string.Empty); }
                    }
                    this.ListaParametrosCondiciones.Add(parametros);

                    // Funcion verdadero
                    string funcion = string.Empty;
                    try
                    { funcion = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, CTransformarCondicional.NodoCondicionesCondicionFuncionVerdadero + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionFuncion); }
                    catch (Exception)
                    { funcion = string.Empty; }

                    this.ListaFuncionesVerdadero.Add(funcion);
                    // No hay función definida
                    if (string.Empty.Equals(funcion))
                    {
                        this.ListaCamposOrigenVerdadero.Add(null);
                        this.ListaCamposDestinoVerdadero.Add(null);
                        this.ListaParametrosVerdadero.Add(null);
                    }
                    // Hay función definida
                    else
                    {
                        string origen = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, CTransformarCondicional.NodoCondicionesCondicionFuncionVerdadero + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionOrigen);
                        this.ListaCamposOrigenVerdadero.Add(origen);

                        string destino = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, CTransformarCondicional.NodoCondicionesCondicionFuncionVerdadero + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionDestino);
                        this.ListaCamposDestinoVerdadero.Add(destino);

                        parametros = new List<string>();
                        numeroParametros = LeerXml.ObtenerNumeroNodosCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionFuncionVerdadero + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionParametros);
                        for (int indiceParametro = 0; indiceParametro < numeroParametros; indiceParametro++)
                        {
                            try
                            {
                                string parametro = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionFuncionVerdadero + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionParametros, indiceParametro);
                                parametros.Add(parametro);
                            }
                            catch (Excepcion)
                            { parametros.Add(string.Empty); }
                        }
                        this.ListaParametrosVerdadero.Add(parametros);
                    }

                    // Funcion falso
                    funcion = string.Empty;
                    try
                    { funcion = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, CTransformarCondicional.NodoCondicionesCondicionFuncionFalso + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionFuncion); }
                    catch (Exception)
                    { funcion = string.Empty; }

                    this.ListaFuncionesFalso.Add(funcion);
                    // No hay función definida
                    if (string.Empty.Equals(funcion))
                    {
                        this.ListaCamposOrigenFalso.Add(null);
                        this.ListaCamposDestinoFalso.Add(null);
                        this.ListaParametrosFalso.Add(null);
                    }
                    // Hay función definida
                    else
                    {
                        string origen = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, CTransformarCondicional.NodoCondicionesCondicionFuncionFalso + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionOrigen);
                        this.ListaCamposOrigenFalso.Add(origen);

                        string destino = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, CTransformarCondicional.NodoCondicionesCondicionFuncionFalso + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionDestino);
                        this.ListaCamposDestinoFalso.Add(destino);

                        parametros = new List<string>();
                        numeroParametros = LeerXml.ObtenerNumeroNodosCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionFuncionFalso + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionParametros);
                        for (int indiceParametro = 0; indiceParametro < numeroParametros; indiceParametro++)
                        {
                            try
                            {
                                string parametro = LeerXml.ObtenerValorCampo(xml, CTransformarCondicional.RutaCondiciones, indiceCondicion, "./" + CTransformarCondicional.NodoCondicionesCondicionFuncionFalso + "/" + CTransformarCondicional.NodoCondicionesCondicionFuncionParametros, indiceParametro);
                                parametros.Add(parametro);
                            }
                            catch (Excepcion)
                            { parametros.Add(string.Empty); }
                            }
                        this.ListaParametrosFalso.Add(parametros);
                    }
                }
            }
        }
    }
}